home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / language / embedded / simulato / v2_3_mc6.tz / v2_3_mc6 / testfiles / main.asm < prev    next >
Assembly Source File  |  1994-05-02  |  16KB  |  351 lines
  1. ******************************************************************************
  2. *       ASSIGNMENT:  #4--Programmer's utility 
  3. *       MODULE:      MAIN.
  4. *       DUE DATE:    12/4/92
  5. *       DESCRIPTION: This program is a utility designed to convert 16 bit
  6. *                    hex or binary integers to their corresponding form.
  7. *                    The hex numbers are given a sign using -, and binary
  8. *                    numbers are assumed to be 2's complement represented.
  9. *                    The command string will ignore spaces in the input.
  10. *                    It will detect invalid characters and numbers that are
  11. *                    out of range of a 16-bit answer. Leading zero's will be
  12. *                    dropped from the input string, and leading zero's will
  13. *                    not be put in the output. (This is why the parse routine
  14. *                    is so long).
  15. *
  16. *******************************************************************************
  17. **** RESOURCES ****
  18. *  D7 -> holds code for command to be executed.
  19. *******************
  20. **** SUBROUTINES ****
  21. * WriteString -- writes string to screen.
  22. * ReadString -- reads user string.
  23. * WriteChar -- writes a single char. to screen
  24. * HEX2BIN -- converts entered hex into binary string.
  25. * BIN2HEX -- converts entered binary into hex string.
  26. *********************
  27.  
  28.         SECTION M,code          ;define section for main
  29.         XREF HEX2BIN,BIN2HEX    ;declare external references.
  30.  
  31. MAIN    JSR WriteEOL            ;write blanks
  32.         JSR WriteEOL            ;so it's easier to read.
  33.         LEA PROMPT,A0           ;load in the prompt.
  34.         JSR WriteString         ;and print to screen.
  35.         LEA NUMBER,A0           ;load place to put entered number.
  36.         JSR ReadString          ;get the number from the user.
  37.         LEA NUMBER,A0           ;load place where # was entered.
  38.         JSR PARSENUM            ;parse the entered number.
  39.         MOVE.B NUM_CASE,D7      ;get the command from the parser
  40.  
  41.         CMPI.B #'$',D7          ;look @ first case.
  42.         BNE.S BIN_CASE          ;if not first look @ nxt.
  43.  
  44. HEX_CASE MOVE.W D3,-(A7)        ;push neg flag onto stack.
  45.         LEA BIN_STR,A5          ;load place of binary string to reg.
  46.         MOVE.L A5,-(A7)         ;push onto stack.
  47.         MOVE.L A2,-(A7)         ;load last chr. of parsed string
  48.         JSR HEX2BIN             ;change input to binary string.
  49.         MOVEA.L (A7)+,A2        ;clean up the stack.
  50.         MOVEA.L (A7)+,A5        ;to avoid problems.
  51.         MOVE.W (A7)+,D3         ;of stack overflow.
  52.         JSR WriteEOL            ;make a blank.
  53.         JSR WriteEOL            ;so easy to read.
  54.         LEA START_MSG,A0        ;load first part of output.
  55.         JSR WriteString         ;print out to screen
  56.         LEA P_NUM,A0            ;load the parsed number.
  57.         JSR WriteString         ;print to screen.
  58.         LEA HEX_EQ_BIN,A0       ;load to print equal sign and %
  59.         JSR WriteString         ;print to screen.
  60.         LEA BIN_STR,A0          ;load output binary string
  61.         JSR WriteString         ;print to screen.
  62.         BRA.W MAIN              ;begin again.
  63.  
  64. BIN_CASE CMPI.B #'%',D7         ;see if number was a binary entry.
  65.         BNE.W INV_CASE          ;else look at next possibility.
  66.         MOVE.W D3,-(A7)         ;move return param on stack 4 balance.
  67.         LEA HEX_STR,A5          ;load place to store hex string.
  68.         MOVE.L A5,-(A7)         ;and store on stack for pass.
  69.         LEA P_NUM+1,A2          ;load 1st chr. of string to be converted.
  70.         MOVE.L A2,-(A7)         ;and store on stack for pass.
  71.         JSR BIN2HEX             ;change input string to hex string.
  72.         MOVEA.L (A7)+,A2        ;clean up the stack
  73.         MOVEA.L (A7)+,A5        ;to avoid problems of overflow.
  74.         MOVE.W (A7)+,D3         ;load return param. of neg. flag.
  75.         JSR WriteEOL            ;make blanks for
  76.         JSR WriteEOL            ;easy reading.
  77.         LEA START_MSG,A0        ;load first part of output.
  78.         JSR WriteString         ;print to screen.
  79.         LEA P_NUM,A0            ;load parsed number.
  80.         JSR WriteString         ;print to screen.
  81.         LEA EQUALS,A0           ;load spacing and equals sign.
  82.         JSR WriteString         ;print to screen.
  83.         TST.W D3                ;test the negaitve flag.
  84.         BEQ.S 1$                ;if 0 the # is pos so branch
  85.         MOVE.B #'-',D0          ;else is neg
  86.         JSR WriteChar           ;so print negative char.
  87. 1$      MOVE.B #'$',D0          ;load in the hex symbol
  88.         JSR WriteChar           ;print to screen.
  89.         LEA HEX_STR,A0          ;load the results
  90.         JSR WriteString         ;and print to the screen.
  91.         BRA.W MAIN              ;begin agian.
  92.  
  93. INV_CASE CMPI.B #'!',D7         ;compare to invalid char. case.
  94.         BNE.S BIG_CASE          ;else look @ nxt. case.
  95.         JSR WriteEOL            ;spacing.
  96.         JSR WriteEOL            ;spacing.
  97.         LEA INV_MSG,A0          ;load error msg.
  98.         JSR WriteString         ;and print to screen.
  99.         LEA NUMBER,A0           ;load in erroneous number.
  100.         JSR WriteString         ;print to screen.
  101.         LEA HELP_MSG,A0         ;load in helpfull msg.
  102.         JSR WriteString         ;and print to screen.
  103.         BRA.W MAIN              ;and begin again.
  104.  
  105. BIG_CASE CMPI.B #'*',D7         ;compare to out of range case.
  106.         BNE.S END_CASE          ;ele look @ nxt.
  107.         JSR WriteEOL            ;spacing.
  108.         JSR WriteEOL            ;spacing.
  109.         LEA BIG_MSG,A0          ;load error msg.
  110.         JSR WriteString         ;and print to screen.
  111.         LEA NUMBER,A0           ;load errorneous number.
  112.         JSR WriteString         ;print to screen.
  113.         LEA HELP_MSG,A0         ;load in nice msg.
  114.         JSR WriteString         ;and print to screen.,
  115.         BRA.W MAIN              ;try again
  116.  
  117. END_CASE CMPI.B #'.',D7         ;compare to end char.
  118.         BNE.S WHAT_CASE         ;else invalid char.
  119.         BRA.S END_IT_ALL        ;end program.
  120.  
  121. WHAT_CASE JSR WriteEOL          ;spacing
  122.         JSR WriteEOL            ;spacing
  123.         LEA NUMBER,A0           ;load erroroneous commmand
  124.         JSR WriteString         ;and print to screen.
  125.         LEA WHAT_MSG,A0         ;load error msg.
  126.         JSR WriteString         ;print 
  127.         BRA.W MAIN              ;try agian.
  128.  
  129. END_IT_ALL MOVE #228,D7         ;end routine.
  130.         TRAP #14                ;ends prog.
  131.  
  132.  
  133. OH_NO   BRA.S OH_NO             ;you really screwd up if you're here.
  134.  
  135.  
  136. **** SUBROUTINE PARSENUM ****
  137. * The purpose of this subroutine is to take the user input string, which
  138. * may contain upper or lower case letters, numbers, or other spurious
  139. * characters and place them in a standard format.  This routine also
  140. * checks to see if conversion is possible.
  141. *****************************
  142. **** RESOURCES ****
  143. * INPUTS: A0 -> input string.
  144. * OUTPUT: A2 -> pointer to last character in string.
  145. *         D3 -> negative flag.
  146. *         P_NUM -> memory location, parsed string.
  147. *         NUM_CASE -> memory location, action to be taken by main.
  148. * HF -> memory location, HEX OR BINARY INPUT FLAG.
  149. * D0 -> digit counter.
  150. * D1 -> character being operated on.
  151. ********************
  152.  
  153. PARSENUM CLR.L D3               ;clear the negative flag.
  154.         CLR.L D0                ;clear the counter.
  155.         CLR.L D4                ;clear found chr. other than leading 0
  156.         LEA P_NUM,A2            ;load in place of output str.
  157.  
  158. P_FIRST MOVE.B (A0)+,D1         ;move in first chr. in string.
  159.  
  160.         CMPI.B #'A',D1          ;look for upper-case chr.
  161.         BLT.S P_NOTCHR          ;if less than 'A' it is not a chr.
  162.         CMPI.B #'F',D1          ;look @ upper limit for upper cse.
  163.         BGT.S P_NOTUCHR         ;if greater cannot be upper case.
  164.         BRA.S P_SETHEX          ;else it is a chr. and the # is hex.
  165.  
  166. P_NOTUCHR CMPI.B #'a',D1        ;look @ lower case chr.
  167.         BLT.S P_NOTCHR          ;if less than 'a' it is not a char.
  168.         CMPI.B #'f',D1          ;look @ upper limit for lower case.
  169.         BGT.S P_NOTCHR          ;if greater it is not a lower chr.
  170.         SUBI.B #$20,D1          ;make chr. upper case.
  171.         BRA.S P_SETHEX          ;else it is a lower chr. and the # is hex.
  172.  
  173. P_NOTCHR CMPI.B #'0',D1         ;compare to lower bounds for #
  174.         BLT.S P_NOTNUM          ;if it is lower it is not a #
  175.         CMPI.B #'9',D1          ;compare to upper bounds for #
  176.         BGT.S P_NOTNUM          ;if it is higher then it is not #
  177.         BRA.S P_SETHEX          ;else it is a number and the # is hex.
  178.  
  179. P_NOTNUM CMPI.B #'%',D1         ;compare to binary string format chr.
  180.         BNE.S P_NOTBIN          ;if it is not then # is not binary.
  181.         BRA.S P_SETBIN          ;else # is bin and set up.
  182.  
  183. P_NOTBIN CMPI.B #'-',D1         ;compare to negative format chr.
  184.         BNE.S P_NOTNEG          ;if it is not then look for end
  185.         BRA.S P_SETNEG          ;else it is neg. so set it.
  186.  
  187. P_NOTNEG CMPI.B #0,D1           ;compare to end of string.
  188.         BNE.S P_NOTEND          ;if it is not end look for space.
  189.         MOVE.B #'?',NUM_CASE    ;else the command is unknown put in chr.
  190.         BRA.W END_PARSE         ;and return.
  191.  
  192. P_NOTEND CMPI.B #' ',D1         ;compare to the space chr.
  193.         BEQ.W P_FIRST           ;if equal keep looking.
  194.  
  195.         CMPI.B #'.',D1          ;compare to exit chr.
  196.         BNE.S P_NOTEXIT         ;if it is
  197.         MOVE.B #'.',NUM_CASE    ;place control chr.
  198.         BRA.W END_PARSE         ;and return.
  199.  
  200. P_NOTEXIT MOVE.B #'!',NUM_CASE  ;else there is an invalid chr. so
  201.         BRA.W END_PARSE         ;return.
  202.  
  203. P_SETNEG MOVE.B #'-',(A2)       ;put the chr. into the parse string.
  204.         ADDQ.W #1,D3            ;set the negative flag.
  205.  
  206. P_SETHEX MOVE.W #1,HF           ;set the hex flag.
  207.         TST.W D3                ;see if # was negative.
  208.         BEQ.S P_POS             ;if zero # is positive.
  209.         ADDQ.L #1,A2            ;if negative pre-increment pointer.
  210. P_POS   MOVE.B #'$',(A2)        ;else move in format for hex #
  211.         MOVE.B #'$',NUM_CASE    ;and set control chr. for main.
  212.         TST.W D3                ;test neg. flag again
  213.         BNE.S P_FIND2END        ;if # is neg. there is still no chr
  214.         CMPI.B #'0',D1          ;look for leading 0
  215.         BEQ.S P_FIND2END        ;if is there is still no chr.
  216.         MOVE.W #1,D4            ;move non-leading zero flag.
  217.         ADDQ.L #1,A2            ;else there is so place in pre inc. ptr.
  218.         MOVE.B D1,(A2)          ;and place chr. in parse string.
  219.         ADDQ.W #1,D0            ;increment digit counter.
  220.         BRA.S P_FIND2END        ;continue the process.
  221.  
  222. P_SETBIN MOVE.B #'%',NUM_CASE   ;put in binary control chr.
  223.         MOVE.B #'%',(A2)        ;move format chr. in parse string.
  224.  
  225. P_FIND2END MOVE.B (A0)+,D1      ;load the next chr.
  226.  
  227.         CMPI.B #'A',D1          ;compare to lower bounds for upper
  228.         BLT.S P_NUMBER          ;if lower is not a chr.
  229.         CMPI.B #'F',D1          ;compare to upper bounds for upper.
  230.         BGT.S P_LOWERCSE        ;if higher not an upper case.
  231.         BRA.S P_FOUNDCHR        ;else it is upper so look at chr.
  232.  
  233. P_LOWERCSE CMPI.B #'a',D1       ;compare to lower bounds for lower
  234.         BLT.S P_NUMBER          ;if not is not a chr.
  235.         CMPI.B #'f',D1          ;compare to upper bounds for lower
  236.         BGT.S P_SPACE           ;if higher is invalid so do one other.
  237.         SUBI.B #$20,D1          ;else is lower so make upper.
  238.         BRA.S P_FOUNDCHR        ;and look @ chr.
  239.  
  240. P_NUMBER CMPI.B #'0',D1         ;compare to lower bounds for #
  241.         BLT.S P_NULL            ;If not look a null case.
  242.         CMPI.B #'9',D1          ;compare to upper bounds for #
  243.         BGT.S P_SPACE           ;if not is invalid so do one last.
  244.         BRA.S P_FOUNDNUM        ;else look @ num.
  245.  
  246. P_NULL  CMPI.B #0,D1            ;compare to null chr.
  247.         BEQ.W END_PARSE         ;end of string to parse.
  248.  
  249. P_SPACE CMPI.B #' ',D1          ;compare to space
  250.         BEQ.W P_FIND2END        ;if space get nxt. chr.
  251.         MOVE.B #'!',NUM_CASE    ;set invalid control chr.
  252.         BRA.W END_PARSE         ;and end parse.
  253.  
  254. P_FOUNDCHR TST HF               ;test the hex flag.
  255.         BNE.S P_ISDIGIT         ;if flag is zero then this is invalid
  256.         MOVE.B #'!',NUM_CASE    ;so set control chr. 
  257.         BRA.W END_PARSE         ;and leave.
  258. P_ISDIGIT ADDQ.W #1,D0          ;increment digit counter.
  259.         CMPI.W #4,D0            ;check to see if there are too
  260.         BLE.S P_ISSHORT         ;many digits.
  261.         MOVE.B #'*',NUM_CASE    ;send control chr.
  262.         BRA.W END_PARSE         ;and leave.
  263. P_ISSHORT MOVE.W #1,D4          ;set found non-leading 0 flag.
  264.         ADDQ.L #1,A2            ;else is valid so
  265.         MOVE.B D1,(A2)          ;pre-increment and place in parse string.
  266.         BRA.W P_FIND2END        ;keep looking.
  267.  
  268. P_FOUNDNUM TST.W D4             ;test if leading 0 flag is set.
  269.         BNE.S P_NOT0            ;check if num is a leading 0
  270.         CMPI.B #'0',D1          ;compare to 0 char.
  271.         BNE.S P_NOT0            ;if not 0 add to string
  272.         BRA.W P_FIND2END        ;else ignore.
  273.  
  274. P_NOT0  TST HF                  ;test the hex flag.
  275.         BEQ.S P_NUMISBIN        ;if zero number is binary.
  276.         ADDQ.W #1,D0            ;else increment digit counter.
  277.         CMPI.W #4,D0            ;and check to see if there are too many.
  278.         BLE.S P_ISSMALL         ;if there are 
  279.         MOVE.B #'*',NUM_CASE    ;send control chr.
  280.         BRA.S END_PARSE         ;and leave.
  281. P_ISSMALL MOVE.W #1,D4          ;set non-leading 0 flag.
  282.         ADDQ.L #1,A2            ;else pre-increment and
  283.         MOVE.B D1,(A2)          ;place in parse string.
  284.         BRA.W P_FIND2END        ;keep looking.
  285.  
  286. P_NUMISBIN TST.W D4             ;test if chr. other than leading is found
  287.         BNE.S P_NOTBIN0         ;if not 0 is not a leading 0.
  288.         CMPI.B #'0',D1          ;compare to the 0 char.
  289.         BNE.S P_NOTBIN0         ;if not 0 ok
  290.         BRA.W P_FIND2END        ;else ignore
  291. P_NOTBIN0 ADDQ.W #1,D0          ;increment the digit counter.
  292.         CMPI.B #'1',D1          ;compare to highest binary digit.
  293.         BLE.S P_BININRANGE      ;if number is greater
  294.         MOVE.B #'!',NUM_CASE    ;send control chr.
  295.         BRA.S END_PARSE         ;and leave.
  296. P_BININRANGE CMPI.W #16,D0      ;check the # of digits
  297.         BLE.S P_BINSMALL        ;if less than limit ok
  298.         MOVE.B #'*',NUM_CASE    ;else place control chr.
  299.         BRA.S END_PARSE         ;and leave.
  300. P_BINSMALL CMPI.W #9,D0         ;check for spacing
  301.         BNE.S P_PUT1            ;if is place
  302.         ADDQ.L #1,A2            ;a space into the
  303.         MOVE.B #' ',(A2)        ;output string.
  304. P_PUT1  ADDQ.L #1,A2            ;else pre-increment
  305.         MOVE.B D1,(A2)          ;and place in parse string.
  306.         MOVE.W #1,D4            ;move in found other than leading 0 flg.
  307.         BRA.W P_FIND2END        ;keep looking.
  308.  
  309. END_PARSE MOVE.B #0,1(A2)       ;place term. in string.
  310.         MOVE.W #0,HF            ;clear hex flag for next 
  311.         RTS                     ;return.
  312.  
  313. ;        NOLIST
  314.         DC.W 0
  315.         Include "samples.asm"
  316. ;        LIST
  317.  
  318. **** MESSAGE AND VARIABLE AREA ****
  319. ***********************************
  320.  
  321.         CNOP 0,2
  322. PROMPT DC.B '>> ',0
  323.         CNOP 0,2
  324. START_MSG DC.B '  ',0
  325.         CNOP 0,2
  326. HEX_EQ_BIN DC.B ' = %',0
  327.         CNOP 0,2
  328. INV_MSG DC.B '  You have entered an invalid character in the number',13,10
  329.         DC.B '  ',0
  330.         CNOP 0,2
  331. BIG_MSG DC.B '  The number you have entered is to big for its type',13,10
  332.         DC.B '  ',0
  333.         CNOP 0,2
  334. WHAT_MSG DC.B ' -- What???',0
  335.         CNOP 0,2
  336. HELP_MSG DC.B 13,10,'  Please check your number and try again.',0
  337.         CNOP 0,2
  338. EQUALS  DC.B ' = ',0
  339.         CNOP 0,2
  340. NUMBER  DS.B 40 
  341. P_NUM   DS.B 20
  342. HF      DC.W 0
  343. BIN_STR DS.B 20
  344. HEX_STR DS.B 8
  345. NUM_CASE DC.W 0
  346.  
  347.         END
  348.  
  349.  
  350.  
  351.